//import java.io.*;
//
//public class Main {
//    //使用基本字节流复制文件的方法
//
//    public static void copyWithByteStream(File src, File dest) throws IOException {
//        // 使用 try-with-resources 自动关闭文件流
//        try (FileInputStream fis = new FileInputStream(src);
//             FileOutputStream fos = new FileOutputStream(dest)) {
//
//            byte[] buffer = new byte[1024]; // 设置缓冲区，尽管是基本字节流，我们也按块读写
//            int bytesRead;
//
//            // 每次读取最多1024字节，直到读到文件结尾（-1）
//            while ((bytesRead = fis.read(buffer)) != -1) {
//                fos.write(buffer, 0, bytesRead); // 写入读取到的有效字节
//            }
//        }
//    }
//
//    public static void main(String[] args) {
//        // 指定源文件和目标文件路径
//        File sourceFile = new File("D:/作业/文献检索作业.docx"); // 请根据实际文件修改路径
//        File destFile = new File("D:/test/文献检索作业复制1.docx");
//
//        try {
//            // 记录复制起始时间
//            long start = System.currentTimeMillis();
//
//            // 调用基本字节流方法进行复制
//            copyWithByteStream(sourceFile, destFile);
//
//            // 记录结束时间并打印耗时
//            long end = System.currentTimeMillis();
//            System.out.println("基本字节流耗时：" + (end - start) + " 毫秒");
//        } catch (IOException e) {
//            // 捕捉异常，打印错误信息
//            System.out.println("复制失败：" + e.getMessage());
//        }
//    }
//}


//import java.io.*;
//
//public class Main {
//     //使用缓冲字节流复制文件的方法
//
//    public static void copyWithBufferedStream(File src, File dest) throws IOException {
//        // 使用 try-with-resources 自动关闭资源
//        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
//             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest))) {
//
//            byte[] buffer = new byte[1024]; // 创建一个1KB的缓冲区
//            int bytesRead;
//
//            // 每次读取缓冲区大小的数据，直到读取完毕
//            while ((bytesRead = bis.read(buffer)) != -1) {
//                bos.write(buffer, 0, bytesRead); // 将读取到的字节写入目标文件
//            }
//        }
//    }
//
//    public static void main(String[] args) {
//        // 定义源文件和目标文件的路径
//        File sourceFile = new File("D:/作业/文献检索作业.docx"); // 修改为你实际的文件路径
//        File destFile = new File("D:/test/文献检索作业复制2.docx");
//
//        // 检查目标文件夹是否存在，不存在就创建
//        if (!destFile.getParentFile().exists()) {
//            destFile.getParentFile().mkdirs();
//        }
//
//        try {
//            // 记录复制开始时间
//            long start = System.currentTimeMillis();
//
//            // 调用方法进行文件复制
//            copyWithBufferedStream(sourceFile, destFile);
//
//            // 记录结束时间并输出耗时
//            long end = System.currentTimeMillis();
//            System.out.println("缓冲字节流耗时：" + (end - start) + " 毫秒");
//        } catch (IOException e) {
//            // 捕获并输出异常信息
//            System.out.println("复制失败：" + e.getMessage());
//        }
//    }
//}
//


//import java.io.*;
//
//public class Main {
//
//    // 复制整个目录（包括里面的文件和子目录）
//    public static void copyDirectory(File sourceDir, File targetDir) {
//        // 如果源目录不存在，直接返回
//        if (!sourceDir.exists()) {
//            System.out.println("源目录不存在：" + sourceDir.getAbsolutePath());
//            return;
//        }
//
//        // 如果目标目录不存在就创建
//        if (!targetDir.exists()) {
//            targetDir.mkdirs(); // 创建多级目录
//        }
//
//        // 获取源目录下所有文件和子目录
//        File[] files = sourceDir.listFiles();
//        if (files != null) {
//            for (File file : files) {
//                // 构造目标路径
//                File newTarget = new File(targetDir, file.getName());
//                if (file.isDirectory()) {
//                    // 如果是子目录就递归复制
//                    copyDirectory(file, newTarget);
//                } else {
//                    // 如果是文件就直接复制
//                    copyFile(file, newTarget);
//                }
//            }
//        }
//    }
//
//    // 复制单个文件，使用带缓冲的字节流
//    public static void copyFile(File src, File dest) {
//        BufferedInputStream bis = null;
//        BufferedOutputStream bos = null;
//        try {
//            bis = new BufferedInputStream(new FileInputStream(src));
//            bos = new BufferedOutputStream(new FileOutputStream(dest));
//
//            byte[] buffer = new byte[1024]; // 缓冲区，1KB
//            int bytesRead;
//            while ((bytesRead = bis.read(buffer)) != -1) {
//                bos.write(buffer, 0, bytesRead); // 写入读取到的字节
//            }
//        } catch (IOException e) {
//            // 处理文件复制时的异常
//            System.out.println("文件复制失败：" + e.getMessage());
//        } finally {
//            // 关闭流，确保资源释放
//            try {
//                if (bis != null) bis.close();
//                if (bos != null) bos.close();
//            } catch (IOException e) {
//                System.out.println("关闭流失败：" + e.getMessage());
//            }
//        }
//    }
//
//    public static void main(String[] args) {
//        // 源目录（要复制的）
//        File source = new File("D:/作业");
//
//        // 目标目录（复制到这里）
//        File destination = new File("D:/test/作业");
//
//        long start = System.currentTimeMillis(); // 开始计时
//        copyDirectory(source, destination); // 执行复制
//        long end = System.currentTimeMillis(); // 结束计时
//        System.out.println("目录复制完成，用时：" + (end - start) + " 毫秒");
//    }
//}


import java.io.*;
import java.util.*;

public class Main {

    // 学生类，存储基本信息和成绩
    static class Student {
        String id; // 学号
        String name; // 姓名
        String gender; // 性别
        Map<String, Integer> scores; // 存储课程和对应成绩

        public Student(String id, String name, String gender) {
            this.id = id;
            this.name = name;
            this.gender = gender;
            this.scores = new HashMap<>();
        }

        // 设置某门课的成绩
        public void setScore(String course, int score) {
            scores.put(course, score);
        }

        // 获取某门课的成绩
        public Integer getScore(String course) {
            return scores.get(course);
        }

        // 计算总成绩
        public int getTotalScore() {
            int total = 0;
            for (Integer score : scores.values()) {
                total += score;
            }
            return total;
        }

        // 把学生信息变成字符串，方便保存到文件
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(id).append(" ").append(name).append(" ").append(gender);
            for (Map.Entry<String, Integer> entry : scores.entrySet()) {
                sb.append(" ").append(entry.getKey()).append(":").append(entry.getValue());
            }
            return sb.toString();
        }
    }

    // 管理所有学生
    static class GradeManager {
        private Map<String, Student> students = new HashMap<>(); // 存储学生
        private final String fileName = "D:/test/grades.txt"; // 数据文件路径

        // 从文件加载学生信息
        public void loadFromFile() {
            try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    String[] data = line.split(" ");
                    String id = data[0];
                    String name = data[1];
                    String gender = data[2];
                    Student student = new Student(id, name, gender);
                    // 加载课程成绩
                    for (int i = 3; i < data.length; i++) {
                        String[] courseData = data[i].split(":");
                        String course = courseData[0];
                        int score = Integer.parseInt(courseData[1]);
                        student.setScore(course, score);
                    }
                    students.put(id, student);
                }
            } catch (IOException e) {
                System.out.println("加载数据失败: " + e.getMessage());
            }
        }

        // 保存学生信息到文件
        public void saveToFile() {
            try (BufferedWriter writer = new BufferedWriter(new FileWriter(fileName))) {
                for (Student student : students.values()) {
                    writer.write(student.toString());
                    writer.newLine(); // 换行
                }
            } catch (IOException e) {
                System.out.println("保存数据失败: " + e.getMessage());
            }
        }

        // 添加学生
        public void addStudent(Student student) {
            students.put(student.id, student);
        }

        // 查找学生
        public Student getStudentById(String id) {
            return students.get(id);
        }

        // 修改成绩
        public void updateStudentScore(String id, String course, int score) {
            Student student = students.get(id);
            if (student != null) {
                student.setScore(course, score);
            }
        }

        // 删除学生
        public void deleteStudent(String id) {
            students.remove(id);
        }

        // 返回按总成绩从高到低排序的学生列表
        public List<Student> getSortedStudentsByTotalScore() {
            List<Student> list = new ArrayList<>(students.values());
            list.sort((s1, s2) -> Integer.compare(s2.getTotalScore(), s1.getTotalScore()));
            return list;
        }
    }

    public static void main(String[] args) {
        GradeManager gradeManager = new GradeManager();
        gradeManager.loadFromFile(); // 启动时加载数据

        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.println("===== 成绩管理系统 =====");
            System.out.println("1. 添加学生");
            System.out.println("2. 查询学生成绩");
            System.out.println("3. 修改学生成绩");
            System.out.println("4. 删除学生");
            System.out.println("5. 按总成绩排序");
            System.out.println("6. 保存并退出");

            int choice = scanner.nextInt();
            scanner.nextLine(); // 读掉回车符

            switch (choice) {
                case 1:
                    // 添加学生
                    System.out.print("输入学号：");
                    String id = scanner.nextLine();
                    System.out.print("输入姓名：");
                    String name = scanner.nextLine();
                    System.out.print("输入性别：");
                    String gender = scanner.nextLine();
                    Student student = new Student(id, name, gender);

                    // 输入三门课程成绩
                    for (int i = 1; i <= 3; i++) {
                        System.out.print("输入第 " + i + " 门课程名称：");
                        String course = scanner.nextLine();
                        System.out.print("输入该课程成绩：");
                        int score = Integer.parseInt(scanner.nextLine());
                        student.setScore(course, score);
                    }

                    gradeManager.addStudent(student);
                    break;

                case 2:
                    // 查询
                    System.out.print("输入学号：");
                    id = scanner.nextLine();
                    Student s = gradeManager.getStudentById(id);
                    if (s != null) {
                        System.out.println("学生信息：" + s);
                    } else {
                        System.out.println("找不到该学生。");
                    }
                    break;
                case 3:
                    // 修改成绩
                    System.out.print("输入学号：");
                    id = scanner.nextLine();
                    System.out.print("输入课程名：");
                    String course = scanner.nextLine();
                    System.out.print("输入成绩：");
                    int score = scanner.nextInt();
                    gradeManager.updateStudentScore(id, course, score);
                    break;
                case 4:
                    // 删除
                    System.out.print("输入学号：");
                    id = scanner.nextLine();
                    gradeManager.deleteStudent(id);
                    break;
                case 5:
                    // 排序并输出
                    List<Student> sortedList = gradeManager.getSortedStudentsByTotalScore();
                    for (Student st : sortedList) {
                        System.out.println(st + " 总分: " + st.getTotalScore());
                    }
                    break;
                case 6:
                    // 保存退出
                    gradeManager.saveToFile();
                    System.out.println("已保存数据，程序退出。");
                    return;
            }
        }
    }
}
